class BreakContinueInfo {        
      

        
          }        
      

        
              public function __construct($parentPos) {        
      

        
                  $this->parentPos = $parentPos;        
      

        
              }        
      

        
          class ClassStore {        
      

        
              public function register(ClassEntry $ce) {        
      

        
                  $lcname = strtolower($ce->getName());        
      

        
                  if (isset($this->classes[$lcname])) {        
      

        
                      throw new \RuntimeException(sprintf("Class %s already defined", $ce->getName()));        
      

        
                  }        
      

        
                  $this->classes[$lcname] = $ce;        
      

        
              }        
      

        
              public function exists($name) {        
      

        
                  return isset($this->classes[strtolower($name)]);        
      

        
              }        
      

        
              public function get($name) {        
      

        
                  $name = strtolower($name);        
      

        
                  if (!isset($this->classes[$name])) {        
      

        
                      throw new \RuntimeException(sprintf('Undefined class %s', $name));        
      

        
                  }        
      

        
                  return $this->classes[$name];        
      

        
              }        
      

        
                  return array_keys($this->classes);        
      

        
              }        
      

        
          class CompileException extends \LogicException {        
      

        
          }        
      

        
              public function __construct($message, $line = -1) {        
      

        
                  parent::__construct($message);        
      

        
                  $this->rawLine = (int) $line;        
      

        
              }        
      

        
                  return $this->rawLine;        
      

        
              }        
      

        
          class Compiler {        
      

        
              public function __construct(FunctionStore $functionStore) {        
      

        
                  $this->functionStore = $functionStore;        
      

        
              }        
      

        
              public function setFileName($name, $dir) {        
      

        
                  $this->fileName = $name;        
      

        
                  $this->currentDir = $dir;        
      

        
              }        
      

        
                  return $this->fileName;        
      

        
              }        
      

        
              public function compile(array $ast, Zval\Ptr $returnContext = null) {        
      

        
                  $opArray = new OpArray($this->fileName);        
      

        
                  $this->opArray = $opArray;        
      

        
                  $this->compileTopLevelFunctions($ast);        
      

        
                  $this->compileNodes($ast, $returnContext);        
      

        
                  $opArray[] = new OpLines\ReturnOp(end($ast)->getLine());        
      

        
                  unset($this->opArray);        
      

        
                  return $opArray;        
      

        
              }        
      

        
              protected function compileTopLevelFunctions(array $ast) {        
      

        
                  foreach ($ast as $node) {        
      

        
                      if ($node instanceof \PHPParser_Node_Stmt_Function) {        
      

        
                          $funcData = $this->compileFunction($node);        
      

        
                          $this->functionStore->register($node->namespacedName, $funcData);        
      

        
                          $node->alreadyCompiled = true;        
      

        
                      } elseif ($node instanceof \PHPParser_Node_Stmt_Namespace) {        
      

        
                          $this->compileTopLevelFunctions($node->stmts);        
      

        
                      }        
      

        
                  }        
      

        
              }        
      

        
              protected function compileNodes(array $ast, Zval\Ptr $returnContext = null) {        
      

        
                  foreach ($ast as $node) {        
      

        
                      $this->compileNode($node, $returnContext);        
      

        
                  }        
      

        
              }        
      

        
              protected function compileNode(\PHPParser_Node $node, Zval\Ptr $returnContext = null) {        
      

        
                  $nodeType = $node->getType();        
      

        
                  if (isset($this->operators[$nodeType])) {        
      

        
                      call_user_func_array(        
      

        
                          array($this, 'compile' . $this->operators[$nodeType][0]),        
      

        
                          array_merge(array($node, $returnContext), array_slice($this->operators[$nodeType], 1))        
      

        
                      );        
      

        
                      return;        
      

        
                  }        
      

        
                  $methodName = 'compile_' . $nodeType;        
      

        
                  if (!method_exists($this, $methodName)) {        
      

        
                      var_dump($node);        
      

        
                      throw new CompileException($nodeType . ' not supported yet', $node->line);        
      

        
                  }        
      

        
                  call_user_func(array($this, $methodName), $node, $returnContext);        
      

        
              }        
      

        
              protected function compileChild(\PHPParser_Node $node, $childName, $returnContext = null) {        
      

        
                  $childNode = $node->$childName;        
      

        
                  if (is_null($childNode)) {        
      

        
                      return;        
      

        
                  }        
      

        
                  if (is_scalar($childNode)) {        
      

        
                      $returnContext->setValue($childNode);        
      

        
                  } elseif (is_array($childNode)) {        
      

        
                      $this->compileNodes($childNode, $returnContext);        
      

        
                  } else {        
      

        
                      $this->compileNode($childNode, $returnContext);        
      

        
              }        
      

        
              protected function compileArrayOp($node, $returnContext, $left = 'left') {        
      

        
                  $op1 = Zval::ptrFactory();        
      

        
                  $this->compileChild($node, $left, $op1);        
      

        
                  if ($returnContext) {        
      

        
                      if (!$returnContext->isArray()) {        
      

        
                          $returnContext->setValue($returnContext->toArray());        
      

        
                      }        
      

        
                      $array = $returnContext->toArray();        
      

        
                      $array[] = $op1;        
      

        
                      $returnContext->setValue($array);        
      

        
                  }        
      

        
              }        
      

        
              protected function compileBinaryOp($node, $returnContext, $class, $left = 'left', $right = 'right') {        
      

        
                  $op1 = Zval::ptrFactory();        
      

        
                  $op2 = Zval::ptrFactory();        
      

        
                  $this->compileChild($node, $left, $op1);        
      

        
                  $this->compileChild($node, $right, $op2);        
      

        
                  $this->opArray[] = new $class($node->getLine(), $op1, $op2, $returnContext ?: Zval::ptrFactory());        
      

        
              }        
      

        
              public function compileBinaryAssignOp($node, $returnContext, $class) {        
      

        
                  $property = null;        
      

        
                  $dim = null;        
      

        
                  $op1 = Zval::ptrFactory();        
      

        
                  $op2 = Zval::ptrFactory();        
      

        
                  $prevFetchWrite = $this->fetchWrite;        
      

        
                  $this->fetchWrite = true;        
      

        
                  if ($node->var instanceof \PHPParser_Node_Expr_PropertyFetch) {        
      

        
                      $var = $node->var;        
      

        
                      $property = Zval::ptrFactory();        
      

        
                      $this->compileChild($var, 'var', $op1);        
      

        
                      $this->compileChild($var, 'name', $property);        
      

        
                  } else if ($node->var instanceof \PHPParser_Node_Expr_ArrayDimFetch) {        
      

        
                      $var = $node->var;        
      

        
                      $this->compileChild($var, 'var', $op1);        
      

        
                      if ($var->dim) {        
      

        
                          $dim = Zval::ptrFactory();        
      

        
                          $this->compileChild($var, 'dim', $dim);        
      

        
                      }        
      

        
                  } else {        
      

        
                      $this->compileChild($node, 'var', $op1);